general

Najlepsze praktyki Node.js

Zbiór przydatnych wskazówek i najlepszych praktyk dla deweloperów Node.js

2024-01-20

💭 Join the Discussion

1 comment

Jul 10, 04:11 PM

ss fsd sdsdfsdfd

Najlepsze praktyki Node.js

Node.js to potężna platforma JavaScript, która oferuje wiele możliwości optymalizacji i najlepszych praktyk.

1. Asynchroniczność

Zawsze używaj asynchronicznych operacji:

``javascript


// ✅ Dobrze
const fs = require('fs').promises;
async function readFile(path) {
  try {
    const data = await fs.readFile(path, 'utf8');
    return data;
  } catch (error) {
    console.error('Błąd odczytu pliku:', error);
  }
}
// ❌ Źle
const fs = require('fs');
const data = fs.readFileSync(path, 'utf8'); // Blokuje event loop


2. Obsługa błędów
Zawsze obsługuj błędy:

`javascript


process.on('uncaughtException', (error) => {
  console.error('Nieobsłużony błąd:', error);
  process.exit(1);
});
process.on('unhandledRejection', (reason, promise) => {
  console.error('Nieobsłużone odrzucenie:', reason);
});


3. Zmienne środowiskowe
Używaj zmiennych środowiskowych dla konfiguracji:

`javascript


const config = {
  port: process.env.PORT || 3000,
  dbUrl: process.env.DATABASE_URL || 'localhost',
  nodeEnv: process.env.NODE_ENV || 'development'
};


4. Middleware Express
Organizuj middleware logicznie:

`javascript


const express = require('express');
const app = express();
// Middleware globalne
app.use(express.json());
app.use(express.static('public'));
// Middleware dla logowania
app.use((req, res, next) => {

console.log(${req.method} ${req.path});


  next();
});
// Trasy
app.get('/', (req, res) => {
  res.json({ message: 'Hello World' });
});


5. Optymalizacja dla AWS Lambda

`javascript


// Inicjalizacja poza handlerem
const db = require('./database');
exports.handler = async (event, context) => {
  // Logika handlera
  const result = await db.query('SELECT * FROM posts');
  return {
    statusCode: 200,
    body: JSON.stringify(result)
  };
};

Podsumowanie

Node.js oferuje wiele narzędzi do tworzenia wydajnych aplikacji. Kluczem jest zrozumienie asynchroniczności i właściwa obsługa błędów.